package com.cxyjy.common.util;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;

import java.util.List;
import java.util.Map;
import java.util.UUID;

@Slf4j
public class JObjectUtil {

    private static final int ID_LENGTH = 18;

    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    public static boolean isNotEmpty(Object obj) {
        return isNotEmpty(stringValue(obj));
    }

    public static String stringValue(Object obj) {
        return stringValue(obj, "");
    }

    public static String stringValue(Object obj, String defaultValue) {
        return obj != null ? String.valueOf(obj) : defaultValue;
    }
    public static boolean isLong(Object obj){
        if(obj == null || stringValue(obj).trim().isEmpty()){
            return false;
        }
        try{
            Long.parseLong(obj.toString().trim());
            return true;
        }catch (NumberFormatException e){
            return false;
        }
    }
    /**
     * 返回long，允许返回空
     * @param obj
     * @return 成功返回 Long，失败返回 null
     */
    public static Long longValue(Object obj){
        if(obj == null || stringValue(obj).trim().isEmpty()){
            return null;
        }
        try{
            return Long.parseLong(obj.toString().trim());
        }catch (NumberFormatException e){
            return null;
        }
    }

    public static boolean isEmpty(String str) {
        return str == null || str.trim().length() == 0;
    }

    public static boolean isEmpty(Object obj) {
        return isEmpty(stringValue(obj));
    }

    public static boolean isNull(String str) {
        return str == null ? true : false;
    }

    public static boolean isNull(Object obj) {
        return obj == null ? true : false;
    }

    public static String nullToString(String str) {
        return str == null ? "" : str;
    }


    public static int objectToInt(Object obj) {
        if (obj instanceof Integer) {
            return (Integer) obj;
        } else if (obj instanceof String) {
            try {
                return Integer.parseInt(stringValue(obj));
            } catch (NumberFormatException e) {
                log.info("转换int类型出错，字符串对象不是有效整数");
            }
        }
        return 0;
    }

    /**
     * 产生18位纯数字随机数id
     *
     * @return
     */
    public static synchronized String createId() {
        UUID uuid = UUID.randomUUID();
        String randomNumber = JObjectUtil.stringValue(Math.abs(uuid.getLeastSignificantBits()));//返回getLeastSignificantBits()方法提供的数字绝对值
        return randomNumber.substring(0, ID_LENGTH);
    }

    /**
     * JSONObject返回Map
     *
     * @param obj
     * @return
     * @throws IllegalAccessException
     */
    public static Map<String, Object> toMap(JSONObject obj) {
        return obj;
    }

    /**
     * Object返回Map
     *
     * @param obj
     * @return
     */
    public static Map<String, Object> toMap(Object obj) {
        return (JSONObject) JSON.toJSON(obj);
    }

    public static <T> List<T> jsonArrayToList(String jsonArrayStr,Class<T> clazz){
        JSONArray jsonArray = JSON.parseArray(jsonArrayStr);
        List<T> javaList = (List<T>) jsonArray.toJavaList(clazz);
        return javaList;
    }

    public static <T> List<T> jsonArrayToList(Object jsonArrayObj,Class<?> clazz){
        String jsonArrayStr = stringValue(jsonArrayObj);
        return (List<T>)jsonArrayToList(jsonArrayStr, clazz);
    }

    // 检查字符串是否为有效的 JSON
    public static boolean isValidJson(String json) {
        try {
            JSON.parseObject(json);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    public static Integer toInteger(Object obj) {
        if (obj == null) {
            return null;
        }
        try {
            // 处理字符串情况
            if (obj instanceof String) {
                String str = ((String) obj).trim();
                return str.isEmpty() ? null : Integer.valueOf(str);
            }
            // 处理数字类型（如Long/Double等）
            else if (obj instanceof Number) {
                return ((Number) obj).intValue();
            }
        } catch (NumberFormatException e) {
            // 忽略异常，返回null
        }

        return null;
    }

    /**
     * 检查字符串是否为1～65535的有效整数
     * @param obj 输入对象
     * @return true=有效，false=无效
     */
    public static boolean isValidPortNumber(Object obj) {
        String input = stringValue(obj);
        if (input == null || input.trim().isEmpty()) {
            return false;
        }

        try {
            // 转换为整数
            int num = Integer.parseInt(input.trim());

            // 检查范围
            return num >= 1 && num <= 65535;

        } catch (NumberFormatException e) {
            // 包含非数字字符或超出int范围
            return false;
        }
    }

    /**
     * 判断目标值是否为 val1 和 val2 之间（包含边界）的整数
     * @param target 待判断的目标值
     * @param val1 区间边界值1
     * @param val2 区间边界值2
     * @return 若目标值是两数之间的整数则返回true，否则返回false
     */
    public static boolean isIntegerBetween(Number target, double val1, double val2) {
        // 1. 校验目标值是否为整数（排除null、非整数类型）
        if (target == null) {
            return false;
        }

        // 检查是否为整数（处理double/float的精度问题）
        double targetValue = target.doubleValue();
        if (Math.floor(targetValue) != targetValue) {
            return false;
        }

        // 2. 处理 val1 和 val2 的大小关系（确保 min <= max）
        double min = Math.min(val1, val2);
        double max = Math.max(val1, val2);

        // 3. 判断目标值是否在 [min, max] 区间内
        return targetValue >= min && targetValue <= max;
    }


}
